#ifndef __FICHERO_H__
#define __FICHERO_H__
#include "ArbolB.h"
#include "Producto.h"
#include <stdlib.h>
#include <fstream>
#include <math.h>
#include <list>

using namespace std;

typedef map<int,string>		Marcas;
//template<class CClave>
class CFichero
{
	fstream						m_archivoDato;
	bool						m_valido;
	string						m_nombreEntrada;//nombre de archivo de entrada
	string						m_nombreSalida; //nombre de archiov de salida
	int							m_tamanioArch; //tamanio del archivo para saber en que bloque insertar
	map<int,TIPO_DATO>			m_nroBloques;//es el numero de blque del archivo de datos donde encuentro el registro que busque previamente.
	int							m_indice;
	TIPO_DATO					m_nroBloque;
	Marcas						m_marcas; //vector de marcas
	int 						m_costoProceso; //(CTO_PROC)	

	TIPO_DATO espacioLibreAntiguo; //esto es de control BORRAR
	
	CArbolB<CClavePrimaria>			m_idxPrimario;
	CArbolB<CClaveCandidata>		m_idxCandidata;
	CArbolB<CClaveSecundaria>		m_idxSecNombre;
	CArbolB<CClaveSecundaria>		m_idxSecMarca;
	CArbolB<CClaveSecundariaSec>	m_idxSecNombreSec;
	CArbolB<CClaveSecundariaSec>	m_idxSecMarcaSec;

//	CArbolB<CClaveEspacioLibre>	m_espacioPrimario;
//	CArbolB<CClaveEspacioLibre>	m_espacioCandidata;
//	CArbolB<CClaveEspacioLibre>	m_espacioSecNom;
//	CArbolB<CClaveEspacioLibre>	m_espacioSecMarca;
	CArbolB<CClaveEspacioLibre>	m_espacioDatos;
	CArbolB<CClavePrimaria>		m_espacioSecDatos; //indice secundario para el archivo de datos
	
	typedef vector<void *>		VectorClavesSet;
	VectorClavesSet				m_vectorClavesSet;

//	TIPO_DATO espacioLibreAntiguo; //esto es de control BORRAR

	string generaPresenetacion();
	string generaPrecio();
	string generaMarca(string &numMarca);
	string generaNombre();
	bool validar(int argc, char *argv[]);
	TIPO_DATO getNroBloque();
	int recorrerDatos(string datos);
	void insertarArchDato(string datos);
	void cargarMarcas();
	void cargarBloque(char bloque[],string registro);
	void cargarPresentacion(char bloque[],string registro);
	bool buscarDatos(CClavePrimaria primaria,CProducto &producto);
	void obtenerProximo(TIPO_DATO codProd,string dato,int& posicion);
	void obtenerProximoDatos(TIPO_DATO codProd,string dato,int& posicion);	
	void insertarDatos(string registro,TIPO_DATO &nroBLoque,bool leer);
	void moverHastaCantPresentacion(string registro,int &posReg);
	void incCantPresentacion(CClavePrimaria primaria,char bloque[]);
	void cargarPresentacion(string &strBloque,string registro);
	void AdministrarEspaciosLibres(TIPO_DATO tamInicial,TIPO_DATO tamFinal,TIPO_DATO nuevoEspLibre,TIPO_DATO  nroBloquePrim);
	void eliminarClaves(string clave,TIPO_DATO mascara);
	void obtenerLista(fstream &archivo,CClaveSecundaria &secundaria,list<string> &codProdLista);	
public:
	CFichero(void);
	CFichero(int argc, char *argv[]);
	~CFichero(void);
	
	//METODOS Publicos
	void generarArchivo(int cantReg);
	void procesar();
	void buscar(string registro);
	void insertar(string registro);
	void eliminar(string registro);
	void recorrer(string registro);

	bool buscarPrimaria(string registro,list<CProducto*> &productos);
	bool buscarPrimaria(string codigo, TIPO_DATO &block);
	bool buscarCandidata(string registro,list<CProducto*> &productos);
	bool buscarCandidata(CClaveCandidata candidata,list<CProducto*> &productos);
	bool buscarSecNombre(string registro,list<CProducto*> &productos);
	bool buscarSecNombre(CClaveSecundaria secundaria,list<CProducto*> &productos);
	bool buscarSecMarca(string registro,list<CProducto*> &productos);
	bool buscarSecMarca(CClaveSecundaria secundaria,list<CProducto*> &productos);
	bool buscarDatos(CClavePrimaria primaria,string &dato,int &posicion);

	void eliminarPrimaria(string clave);
	void eliminarCandidata(string registro);
	void eliminarSecNombre(string registro);
	void eliminarSecMarca(string registro);
	void eliminar(string &dato,int posicion);
	void eliminarPresentacion(string codProd,int indice,int nroProducto);
	
	void modificar(CProducto producto,TIPO_DATO nroBloque);
	

	void leerBloque(TIPO_DATO);
	void leerBloque(string indice, TIPO_DATO);

	TIPO_DATO getNroBloqueLeido(){return m_nroBloque;};
	void obtenerLista(fstream &archivo,CClaveSecundaria &secundaria,list<TIPO_DATO> &codProdLista);
	void clear(){m_nroBloques.clear();m_indice=0;}
	void modificarPrecio(string codProd,int indice,int nroProducto,string precio);

	void mostrar(char bloque[]);

	void exportarArchivo(string opcion);
	void exportarVectorClavePrimaria(ofstream *archExport);
	void exportarVectorClaveSecNombre(ofstream *archExport);
	void exportarVectorClaveSecMarca(ofstream *archExport);
	void exportarVectorClaveCandidata(ofstream *archExport);
	
	void inicializarCtoProc(void);//(CTO_PROC)
	void incrementarCtoProc(void){this->m_costoProceso++;}//(CTO_PROC)
	void mostrarCtoProc(void); //(CTO_PROC)
	int getCosto(){return this->m_costoProceso;} 
	
};
/*-----------------------------------------------------------*/
CFichero::CFichero(int argc, char *argv[]):m_idxPrimario((string)NOM_ARCH_INDICE_PRIM),m_idxCandidata((string)NOM_ARCH_INDICE_CAND),
m_idxSecNombre((string)NOM_ARCH_INDICE_SEC_NOM),m_idxSecMarca((string)NOM_ARCH_INDICE_SEC_MARC),
m_idxSecNombreSec((string)NOM_ARCH_INDICE_SEC_NOM_SEC),m_idxSecMarcaSec((string)NOM_ARCH_INDICE_SEC_MARC_SEC),
//m_espacioSecNom((string)NOM_ARCH_ESPACIO_SEC_NOM),m_espacioSecMarca((string)NOM_ARCH_ESPACIO_SEC_MARC),
m_espacioDatos((string)NOM_ARCH_ESPACIO_DATOS),m_espacioSecDatos((string)NOM_ARCH_ESPSEC_DATOS)

{	
	m_tamanioArch=1;
	espacioLibreAntiguo = 0;
	m_indice = 0;
	cargarMarcas();
//	CClaveEspacioLibre *espacioIdx = new CClaveEspacioLibre(TAMANIO_NODO,0);
	CClaveEspacioLibre *espacioDatos = new CClaveEspacioLibre(TAMANIO_BLOQUE_DATO,0);
	CClavePrimaria *secPrim = new CClavePrimaria(0,TAMANIO_BLOQUE_DATO);
//	m_espacioPrimario.insertar(*espacioIdx);
//	m_espacioCandidata.insertar(*espacioIdx);
//	m_espacioSecMarca.insertar(*espacioIdx);
//	m_espacioSecNom.insertar(*espacioIdx);
	m_espacioDatos.insertar(*espacioDatos);
	m_espacioSecDatos.insertar(*secPrim);

	m_valido = validar(argc,argv);
	if(m_valido && !m_archivoDato.is_open()) 
		m_archivoDato.open(m_nombreEntrada.c_str(),ios::in | ios::out | ios::binary | ios::trunc);

	if(m_archivoDato.is_open())
	{
		this->m_archivoDato.seekg(0, ios::end);	//se posiciona al final del archivo
		m_tamanioArch = this->m_archivoDato.tellg(); //indica en que pos del arch se encuentra (en byte)
		this->m_archivoDato.seekg(0, ios::beg);	//se posiciona al inicio del archivo	
	}
	else
		cout<<"El archivo no se pudo abrir!!."<<endl;
}
/*-----------------------------------------------------------*/
CFichero::CFichero(void)
{
	m_indice = 0;
}
/*-----------------------------------------------------------*/
CFichero::~CFichero(void)
{
	if(m_archivoDato.is_open())
		m_archivoDato.close();
}
/*-----------------------------------------------------------*/
//METODOS
void CFichero::procesar()
{
}
/*-----------------------------------------------------------*/
void CFichero::cargarMarcas()
{	/*Esto podria ser temporario*/
	m_marcas[1]= "La Serenisima";
	m_marcas[2]="Sancor";
	m_marcas[3]= "Terabussi";
	m_marcas[4]= "Guaymayen";
	m_marcas[5]= "El Coloso";
	m_marcas[6]= "Pepsi";
	m_marcas[7]= "Coca Cola";
	m_marcas[8]= "Marca8";
	m_marcas[9]="Marca9";
	m_marcas[10]="Marca10";
	m_marcas[11]="Marca11";
	m_marcas[12]="Marca12";
	m_marcas[13]="Marca13";
	m_marcas[14]="Marca14";
	m_marcas[15]="Marca15";
	m_marcas[16]="Marca16";
	m_marcas[17]="Marca17";
	m_marcas[18]="Marca18";
	m_marcas[19]="Marca19";
	m_marcas[20]="Marca20";
	m_marcas[21]="Marca21";
	m_marcas[22]="Marca22";
	m_marcas[23]="Marca23";
	m_marcas[24]="Marca24";
	m_marcas[25]="Marca25";
	m_marcas[26]="Marca26";
	m_marcas[27]="Marca27";
	m_marcas[28]="Marca28";
	m_marcas[29]="Marca29";
	m_marcas[30]="Marca30";
}
/*-----------------------------------------------------------*/
bool CFichero::validar(int argc, char *argv[])
{
	int cantReg=0;
	/*si el usuario no ingresa ningun dato creamos un archivo aleatorio, con la 
	  cantidad, nombre de entrada y salida por dafault */
	if(argc==1)
	{		
		m_nombreEntrada = (string)NOM_ARCH_DATO;
		generarArchivo(CANTIDAD_REG_DEFAULT);
	}
	if(argc>1)	//Si se ingresaron argumentos, los proceso
		if(isNumero(argv[1]))		
		{ /*si es un numero se crea un archivo con la cantidad de registros que pasa
		    el usuario, con un nombre que nosotros ponemos.*/			
			cantReg = atoi(argv[1]);	
			m_nombreEntrada = (string)NOM_ARCH_DATO;
			generarArchivo(cantReg);			
		}
		else
		/*el unico caso que queda es el que pongan el nombre del archivo de entrada*/
			//strcpy(m_nombreEntrada,argv[1]);
			//strcpy(nombreaux,NOMBRE_ENTRADA);
		m_nombreEntrada.append(argv[1]);
			
	/*el usuario tiene la oportunidad de ingresar un nombre para el archivo de salida*/
	if(argc >2) 
		//strcpy(m_nombreSalida,argv[2]);
		m_nombreSalida.append(argv[2]);
	else
		//strcpy(m_nombreSalida,NOMBRE_SALIDA);	
		m_nombreSalida = (string)NOM_ARCH_SALIDA;	
		//abro el archivo de entrada.
/*
	m_entrada.open(m_nombreEntrada);
	if(!m_entrada.is_open())
	{
		cout<<"el archivo no existe"<<endl;
		m_fin=true;
	}


	if(argc==0)
		generarArchivo(10);
	m_nombre = "archivoDato.dat";
	*/
	return true;
}
/*-----------------------------------------------------------*/
 /* CODIGO_PRODUCTO 
  */
/*Genera el archivo de datos y los indices.*/
void CFichero::generarArchivo(int cantRegistros)
{
	
	int i=0, cantMarcas=0, cantPresentacion=0;
	//int contMarca=0,contPres=0;
	char strCantReg[1]={};
	string bloque; //bloque que se escribe en disco
	string producto="", productoAux,productoNomAux,productoMarcAux; //variables donde se arma el producto
	string marcaAux, nombreAux,presentacionAux, precioAux,numMarca; //variables que obtienen una marca y un nombre
	
	strCantReg[0] =(char)cantRegistros;
	bloque = "";

	if(!m_archivoDato.is_open()) 
		m_archivoDato.open(m_nombreEntrada.c_str(),ios::in | ios::out | ios::binary | ios::trunc);

	//PROBAR QUE PASA SI ENTRA UN \0
	bloque.append((string)strCantReg);//en este caracter se carga la cantidad de registros
	cout<<"Se generan "<<cantRegistros<<" productos al azar."<<endl;
	while ( i < cantRegistros )
	{
		producto = "";
		productoAux = "";	
		productoNomAux = "";	
		cantMarcas = 3 + rand()%4; //3...6
		cantPresentacion = 2 + rand()%4; //2...5		
		
		//NOMBRE
		nombreAux = generaNombre();
		productoNomAux += convertirChar( (int)nombreAux.length(),TAMANIO_BYTE_DIN); //longitud del nombre
		productoNomAux += nombreAux; //long + nombre
		
		//CADA NOMBRE DEBE ESTAR CON 3 A 6 MARCAS
		for(int k=0; (k < cantMarcas)&&(i < cantRegistros); k++) 
		{			
			//MARCA 
			marcaAux = generaMarca(numMarca);
			productoMarcAux = convertirChar( (int)marcaAux.length(),TAMANIO_BYTE_DIN); //longitud del nombre
			productoMarcAux += marcaAux; //long + marca
			
			//CODIGO DE PRODUCTO, este campo es el primero
			//producto = nombreAux + numMarca + productoNomAux +productoMarcAux; // seteo el codigo de producto
			producto = numMarca + nombreAux  + productoMarcAux + productoNomAux; // seteo el codigo de producto
			//cantidad de presetaciones
			producto += convertirChar(1,TAMANIO_BYTE_DIN);
			//codProd+nombre+marca debe aparecer con varias presentaciones
			productoAux = producto; //guardo el producto sin los ultimos dos campos
			
			for(int j=0; j < cantPresentacion; j++) 
			{

			//PRESENTACION
			presentacionAux = generaPresenetacion();
			producto += convertirChar( (int)presentacionAux.length(),TAMANIO_BYTE_PRES); //longitud de la presentacion
			producto += presentacionAux;					
			
			//PRECIO
			precioAux = generaPrecio();
			producto += convertirChar( (int)precioAux.length(),TAMANIO_BYTE_DIN); //longitud del precio
			producto += precioAux;	
			
			cout<<endl<<"\t\t"<<"Producto Nro."<<1+i<<": "<<producto<<endl;

			//if(i==473)
			if(i==20)
				cout<<"entro LLEGARA"<<endl;
			insertar(producto);
//			cout<<"Producto despues de insertar:"<<endl<<producto<<endl;
			producto = productoAux; //saco los ultimos dos campos para cilclar con una nueva presentacion y precio			
			i++;
			}				
		}		
	}
}
/*-----------------------------------------------------------*/
bool CFichero::buscarDatos(CClavePrimaria primaria,CProducto &producto)
{
	char bloque[TAMANIO_BLOQUE_DATO+1]={};
	string dato;
	int cantLeida = 0, cantDigitos = 0;
	//unsigned long auxNroBlq = 0, cantLectura=0;
	
	
	int posicion;// posicion en el que encuentra el string

	this->incrementarCtoProc();//(CTO_PROC)
		
	this->m_archivoDato.seekg(TAMANIO_BLOQUE_DATO*(primaria.nroBloque) ,ios::beg);
	this->m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO );
	m_nroBloques[m_indice++] = primaria.getNroBloque();
	if(this->m_archivoDato.bad())
		cout<<"El archivo es malo"<<endl;
	cantLeida = (int)this->m_archivoDato.gcount();
	if( cantLeida > 0 )
	{
		dato.append(bloque);
		posicion = (int)dato.find(itoa(primaria.codProd));	
		if(posicion<0)
			obtenerProximo(primaria.codProd,dato,posicion);
		else
		{	
			cantDigitos = (int)log10((double)primaria.codProd) + 1;
			while(cantDigitos<5)
			{
				--posicion;
				++cantDigitos;
			}
		}
		producto.setProducto(dato.substr(posicion,(int)dato.length()));
	}
	else
	{
		cout<<"No se leyo nada del archivo de Datos."<<endl;
	}
	return false;
}
/*********************************************************************************/
bool CFichero::buscarDatos(CClavePrimaria primaria,string &dato,int &posicion)
{
    bool encontrado=false;
    int cantReg,i=0,tamanio=0;
    TIPO_DATO codigoAux,cantPres,codProd;
    string strcodProd=""; 
    posicion=0;
    codProd =primaria.getClave();
    cantReg = (unsigned char)(dato.substr(posicion,TAMANIO_CANTIDAD_REGISTRO).c_str()[0]);
    if(cantReg == 0)
        posicion = 0;
    posicion += TAMANIO_CANTIDAD_REGISTRO; 
    while(i<cantReg && !encontrado)
    {    //CODIGO
        strcodProd = dato.substr(posicion,5); 
        codigoAux = atoi(strcodProd .c_str());
        if(codProd==codigoAux)
            return true;     
//        else if((i+1)==cantReg)//es el ultimo y el codigo sigue siendo el mayir
//            return;
        //Salteo todo el producto hasta el siguiente codigo
        posicion+=5;
        //MARCA
        tamanio = string2TipoDato( dato.substr(posicion,TAMANIO_BYTE_DIN));
        posicion+=TAMANIO_BYTE_DIN;            
        posicion+=tamanio;
        //NOMBRE
        tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
        posicion+=TAMANIO_BYTE_DIN;            
        posicion+=tamanio;
        
        //cantidad de presentaciones
        cantPres = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
        posicion+= TAMANIO_BYTE_DIN; 
        for(unsigned int j=0;j<cantPres;j++)
        {
            //PRESENTACION
            tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_PRES));
            posicion+=TAMANIO_BYTE_PRES;     
            posicion+=tamanio;
            //PRECIO
            tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
            posicion+=TAMANIO_BYTE_DIN;
            posicion+=tamanio;     
        }
        ++i;        
    }

    cout<<"No se encontro el dato buscado"<<endl;
    return false;

	
	/* ANTES DE LA NUEVA VERSION 
//	char bloque[TAMANIO_BLOQUE_DATO+1]={};
	//string dato;
	int cantDigitos = -1;
	unsigned long auxNroBlq = 0, cantLectura=0;
	auxNroBlq = primaria.nroBloque;
	cantLectura = TAMANIO_BLOQUE_DATO * (auxNroBlq );
	posicion=0;
	//int posicion;// posicion en el que encuentra el string

//	if(m_archivoDato.is_open())
//		this->m_archivoDato.close();
		
//	if(!m_archivoDato.is_open()) 
//		m_archivoDato.open(m_nombreEntrada.c_str(),ios::in | ios::out | ios::binary );

//	long tama = -111;	
//	this->m_archivoDato.seekg(0, ios::end);	//se posiciona al final del archivo
//	tama = this->m_archivoDato.tellg(); //indica en que pos del arch se encuentra (en byte)
//	this->m_archivoDato.seekg(0, ios::beg);	//se posiciona al inicio del archivo	
	
//	this->m_archivoDato.seekg(cantLectura ,ios::beg);
	//this->m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO );
//	TIPO_DATO espacioLibre ;
//	espacioLibre = TAMANIO_BLOQUE_DATO -(TIPO_DATO)strlen(bloque);
///	if(auxNroBlq ==this->getNroBloque() && espacioLibre != espacioLibreAntiguo)
//		cout<<"ESTAMAL !!!!!!!!"<<endl;
	
	m_nroBloques[m_indice++] =primaria.getNroBloque();
	//if(this->m_archivoDato.bad())
//		cout<<"El archivo es malo"<<endl;
//	cantLeida = (int)this->m_archivoDato.gcount();
	if( (int)dato.length() > 0 )
	{
		//dato.append(bloque);
		posicion = (int)dato.find(itoa(primaria.codProd));	
		if(posicion<0)
		{
			cout<<"Error al buscar el codigo en el bloque del dato."<<endl;
			return false;
		}
		cantDigitos = (int)log10((double)primaria.codProd) + 1;
		while(cantDigitos<5)
		{
			--posicion;
			++cantDigitos;
		}
		return true;
		
	}
	cout<<"No se leyo nada del archivo de Datos."<<endl;
	return false;
	*/
}

/*-----------------------------------------------------------*/
bool CFichero::buscarPrimaria(string codigo, TIPO_DATO &block)
{
	block=0;
	
	m_idxPrimario.inicializarCosto(); //(CTO_PROC)
		
	CClavePrimaria primaria(codigo);
	if(!m_idxPrimario.buscar(primaria,block))
		return false;
	block = primaria.nroBloque;
	return true;
}

/*-----------------------------------------------------------*/
bool CFichero::buscarPrimaria(string clave,list<CProducto*> &lista)
{
	bool encontro =false;
	
	m_idxPrimario.inicializarCosto(); //(CTO_PROC)
		
	CProducto *producto = new CProducto;
	TIPO_DATO nroBlock=0;
	CClavePrimaria primaria(clave);
	if(!(encontro =m_idxPrimario.buscar(primaria,nroBlock)))
	{
		TIPO_DATO siguiente;
		if((siguiente=m_idxPrimario.getSiguiente())==0)
			primaria =m_idxPrimario.getClaveAux(); 
		else
		{
			m_idxPrimario.leerClaveDeBloque(siguiente,primaria);
		}
	}
	//primaria.nroBloque;
	m_nroBloque = primaria.nroBloque;
	//buscar(nroBlock); //busca en el archivo de dato y muestra los datos encontrados 
	buscarDatos(primaria,*producto);
	lista.insert(lista.begin(),producto);
	return encontro;
}
/*-----------------------------------------------------------*/
bool CFichero::buscarCandidata(string registro,list<CProducto*> &lista)
{
	bool encontro =false;
	
	m_idxCandidata.inicializarCosto(); //(CTO_PROC)
		
	TIPO_DATO nroBlock=0;
	CProducto *producto = new CProducto;
	CClaveCandidata candidata(registro);
	if(!(encontro = m_idxCandidata.buscar(candidata,nroBlock)))
		candidata = m_idxCandidata.getClaveAux(); 

	CClavePrimaria primaria(candidata.getCodProducto());
	if(!(encontro = m_idxPrimario.buscar(primaria,nroBlock)))
		primaria = m_idxPrimario.getClaveAux(); 
	//primaria.nroBloque;
	m_nroBloque = primaria.nroBloque;
	//buscar(nroBlock); //busca en el archivo de dato y muestra los datos encontrados 
	buscarDatos(primaria,*producto);
	lista.insert(lista.begin(),producto);
	return encontro;

}

/*-----------------------------------------------------------*/
bool CFichero::buscarCandidata(CClaveCandidata candidata,list<CProducto*> &lista)
{
	bool encontro =false;
	TIPO_DATO nroBlock=0;
	CProducto *producto = new CProducto;
	//CClaveCandidata candidata(registro);
	if(!(encontro = m_idxCandidata.buscar(candidata,nroBlock)))
		candidata = m_idxCandidata.getClaveAux(); 

	CClavePrimaria primaria(candidata.getCodProducto());
	if(!(encontro = m_idxPrimario.buscar(primaria,nroBlock)))
		primaria = m_idxPrimario.getClaveAux(); 
	//primaria.nroBloque;
	m_nroBloque = primaria.nroBloque;
	//buscar(nroBlock); //busca en el archivo de dato y muestra los datos encontrados 
	buscarDatos(primaria,*producto);
	lista.insert(lista.begin(),producto);
	return encontro;

}

/*-----------------------------------------------------------*/
void CFichero::obtenerLista(fstream &archivo,CClaveSecundaria &secundaria,list<TIPO_DATO> &codProdLista)
{
	TIPO_DATO		nroBloque,cantCod;
	string			dato="";
	int				posicion=0;
	char			bloque[TAMANIO_LISTA_COD]={};
	list<TIPO_DATO>::iterator it;//para pruebas
	unsigned int i;
	cantCod = secundaria.getIndice();
	for(i=0;i<cantCod && i<(CANT_CODIGOS-1);i++)
		codProdLista.insert(codProdLista.end(),secundaria.getCodProd(i));
//	for(it=codProdLista.begin();(it)!=codProdLista.end();it++)
//		cout<<"CODIGOS ::::::::"<<(*it)<<endl;
	nroBloque = secundaria.getCodProd(i);
	//cantCod = secundaria.getIndice();
	while(CANT_CODIGOS== cantCod)
	{
		archivo.seekg(TAMANIO_LISTA_COD*nroBloque,ios::beg);
		archivo.read(bloque,TAMANIO_LISTA_COD);
		dato.append(bloque);
		cantCod =string2TipoDato(dato.substr(posicion,TAMANIO_CANTIDAD_REGISTRO));
		posicion += TAMANIO_CANTIDAD_REGISTRO;
		nroBloque =string2TipoDato(dato.substr(posicion,TAMANIO_COD_PROD));
		posicion += TAMANIO_COD_PROD;
		for(unsigned int i=0;i<cantCod;i++)
		{
			codProdLista.insert(codProdLista.end(),string2TipoDato(dato.substr(posicion,TAMANIO_COD_PROD)));
			posicion += TAMANIO_COD_PROD;
		}

	}
}

/*-----------------------------------------------------------*/
bool CFichero::buscarSecNombre(string registro,list<CProducto*> &lista)
{
	bool						encontro =false;	
	list<TIPO_DATO>				codProdLista;
	list<TIPO_DATO>::iterator   it;
	//TIPO_DATO					codProd;
	TIPO_DATO					nroBlock=0;	
	CClaveSecundaria			secundaria(registro);
	
	m_idxSecNombre.inicializarCosto(); //(CTO_PROC)
	m_idxPrimario.inicializarCosto();	
		
	if(!(encontro =m_idxSecNombre.buscar(secundaria,nroBlock)))
		secundaria=m_idxSecNombre.getClaveAux(); 

	obtenerLista(m_idxSecNombre.getArchivo(),secundaria,codProdLista);
	//while(secundaria.getCodProd(indice,codProd))
	for(it=codProdLista.begin();it!=codProdLista.end();it++)
	{
		CProducto *producto = new CProducto;
		CClavePrimaria primaria((*it));
		if(!(encontro =m_idxPrimario.buscar(primaria,nroBlock)))
			primaria =m_idxPrimario.getClaveAux(); 
		//primaria.nroBloque;
		m_nroBloque = primaria.nroBloque;
		//buscar(nroBlock); //busca en el archivo de dato y muestra los datos encontrados 
		buscarDatos(primaria,*producto);
		lista.insert(lista.begin(),producto);
	}
	return encontro;

}
/*-----------------------------------------------------------*/
bool CFichero::buscarSecNombre(CClaveSecundaria secundaria,list<CProducto*> &lista)
{
	bool						encontro =false;	
	list<TIPO_DATO>				codProdLista;
	list<TIPO_DATO>::iterator   it;
	//TIPO_DATO					codProd;
	TIPO_DATO					nroBlock=0;	
	//CClaveSecundaria			secundaria(registro);

	m_idxSecNombre.inicializarCosto(); //(CTO_PROC)
	m_idxPrimario.inicializarCosto();
	
	if(!(encontro =m_idxSecNombre.buscar(secundaria,nroBlock)))
		secundaria=m_idxSecNombre.getClaveAux(); 

	obtenerLista(m_idxSecNombre.getArchivo(),secundaria,codProdLista);
	//while(secundaria.getCodProd(indice,codProd))
	for(it=codProdLista.begin();it!=codProdLista.end();it++)
	{
		CProducto *producto = new CProducto;
		CClavePrimaria primaria((*it));
		if(!(encontro =m_idxPrimario.buscar(primaria,nroBlock)))
			primaria =m_idxPrimario.getClaveAux(); 
		//primaria.nroBloque;
		m_nroBloque = primaria.nroBloque;
		//buscar(nroBlock); //busca en el archivo de dato y muestra los datos encontrados 
		buscarDatos(primaria,*producto);
		lista.insert(lista.begin(),producto);
	}
	return encontro;
}
/*-----------------------------------------------------------*/
bool CFichero::buscarSecMarca(string registro,list<CProducto*> &lista)
{
	bool						encontro =false;	
	list<TIPO_DATO>				codProdLista;
	list<TIPO_DATO>::iterator   it;	
	TIPO_DATO					nroBlock=0;	
	CClaveSecundaria			secundaria(registro,false);
	
	m_idxSecMarca.inicializarCosto(); //(CTO_PROC)
	m_idxPrimario.inicializarCosto();
	
		if(!(encontro =m_idxSecMarca.buscar(secundaria,nroBlock)))
		secundaria=m_idxSecMarca.getClaveAux(); 

	obtenerLista(m_idxSecMarca.getArchivo(),secundaria,codProdLista);
	//while(secundaria.getCodProd(indice,codProd))
	for(it=codProdLista.begin();it!=codProdLista.end();it++)
	{
		CProducto *producto = new CProducto;
		CClavePrimaria primaria((*it));
		if(!(encontro =m_idxPrimario.buscar(primaria,nroBlock)))
			primaria =m_idxPrimario.getClaveAux(); 
		//primaria.nroBloque;
		m_nroBloque = primaria.nroBloque;
		//buscar(nroBlock); //busca en el archivo de dato y muestra los datos encontrados 
		buscarDatos(primaria,*producto);
		lista.insert(lista.begin(),producto);
	}
	return encontro;
}

/*-----------------------------------------------------------*/
bool CFichero::buscarSecMarca(CClaveSecundaria secundaria,list<CProducto*> &lista)
{
	bool						encontro =false;	
	list<TIPO_DATO>				codProdLista;
	list<TIPO_DATO>::iterator   it;	
	TIPO_DATO					nroBlock=0;	
	//CClaveSecundaria			secundaria(registro,false);

	m_idxSecMarca.inicializarCosto(); //(CTO_PROC)
	m_idxPrimario.inicializarCosto();
	
	if(!(encontro =m_idxSecMarca.buscar(secundaria,nroBlock)))
		secundaria=m_idxSecMarca.getClaveAux(); 

	obtenerLista(m_idxSecMarca.getArchivo(),secundaria,codProdLista);
	//while(secundaria.getCodProd(indice,codProd))
	for(it=codProdLista.begin();it!=codProdLista.end();it++)
	{
		CProducto *producto = new CProducto;
		CClavePrimaria primaria((*it));
		if(!(encontro =m_idxPrimario.buscar(primaria,nroBlock)))
			primaria =m_idxPrimario.getClaveAux(); 
		//primaria.nroBloque;
		m_nroBloque = primaria.nroBloque;
		//buscar(nroBlock); //busca en el archivo de dato y muestra los datos encontrados 
		buscarDatos(primaria,*producto);
		lista.insert(lista.begin(),producto);
	}
	return encontro;
}

void CFichero::modificarPrecio(string codProd,int indice,int nroProducto,string precio)
{
	char bloque[TAMANIO_BLOQUE_DATO+1]={};
	string dato="";
	CClavePrimaria *primaria = new CClavePrimaria(atoi(codProd.c_str()),m_nroBloques[nroProducto]);
	int cantLeida,posicion,posCantPres,posInicial;
	TIPO_DATO cantPres,tamInicial=0,tamFinal=0;
	m_archivoDato.seekg(TAMANIO_BLOQUE_DATO* m_nroBloques[nroProducto],ios::beg);
	m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO);
	dato.append(bloque);
	tamInicial = (TIPO_DATO)dato.length();
	cantLeida = (int)this->m_archivoDato.gcount();
	if( cantLeida > 0 )
	{
		if(!buscarDatos(*primaria,dato,posicion))
		{
			cout<<"No se encontro los datos"<<endl;
			return;
		}
	//	obtenerProximoDatos(primaria->getCodProducto(),dato,posFinal);
	//	if(posFinal<2)
	//		posFinal = (int)dato.length();	
	//	strRegAux +=dato.substr(posicion,posFinal - posicion);
		moverHastaCantPresentacion(dato,posicion);
		cantPres = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posCantPres=posicion;
		posicion+=TAMANIO_BYTE_DIN;
		for(int i=0;i<(indice);i++)
		{
			if((TIPO_DATO)indice>cantPres)
			{
				cout<<"La presentacion que quiere borrar no existe"<<endl;
				return;
			}
			//PRESENTACION
			posicion += string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_PRES));
			posicion+=TAMANIO_BYTE_PRES;				
			if((i+1)==(indice))
				posInicial=posicion;
			//PRECIO
			posicion += string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
			posicion+=TAMANIO_BYTE_DIN;			
			//i++;
		}
		dato.replace(posInicial,posicion-posInicial,convertirChar((int)precio.length(),TAMANIO_BYTE_DIN)+precio);
		strncpy(bloque,dato.c_str(),TAMANIO_BLOQUE_DATO);
		m_archivoDato.seekp(TAMANIO_BLOQUE_DATO* m_nroBloques[nroProducto],ios::beg);
		m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO);
	//	m_nroBloques.erase(nroProducto);
	//	mostrar(bloque);
		//ESTO NO ESTA TAMBIEN PORQUE TENDRIAMOS QUE CHEQUEAR QUE EL NUEVO PRECIO INGRESADO NO SOBREPASE EL TAMANIO DEL NODO
		//DE ESTA MANERA TENDRIAMOS QUE MOVER EL REGISTRO A OTRO NODO Y MODIFICAR TODOS LOS INDICES
		//ESTO ES MUY COSTOSO I Y COMO SOLO ES EL PRECIO Y SE SUPONE QUE NO VAN A PONER UN PRECIO TANGRANDE ( ES LO MAS PROBABLE)
		tamFinal = (TIPO_DATO)strlen(bloque);
		AdministrarEspaciosLibres(tamInicial,tamFinal,TAMANIO_BLOQUE_DATO -tamFinal,m_nroBloques[nroProducto]);

	}
	else
		cout<<"No se encontro el dato"<<endl;
}
/*-----------------------------------------------------------*/
void CFichero::eliminarPresentacion(string codProd,int indice,int nroProducto)
{
	char bloque[TAMANIO_BLOQUE_DATO+1]={};
	string dato="";
	CClavePrimaria *primaria = new CClavePrimaria(atoi(codProd.c_str()),m_nroBloques[nroProducto]);
	int cantLeida,posicion,posCantPres,posInicial;
	TIPO_DATO cantPres,tamInicial=0,tamFinal=0;
	m_archivoDato.seekg(TAMANIO_BLOQUE_DATO* m_nroBloques[nroProducto],ios::beg);
	m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO);
	dato.append(bloque);
	tamInicial = (TIPO_DATO)dato.length();
	cantLeida = (int)this->m_archivoDato.gcount();
	if( cantLeida > 0 )
	{
		//dato.append(bloque);
		if(!buscarDatos(*primaria,dato,posicion))
		{
			cout<<"No se encontro los datos"<<endl;
			return;
		}
	//	obtenerProximoDatos(primaria->getCodProducto(),dato,posFinal);
	//	if(posFinal<2)
	//		posFinal = (int)dato.length();	
	//	strRegAux +=dato.substr(posicion,posFinal - posicion);

		moverHastaCantPresentacion(dato,posicion);
		cantPres = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posCantPres=posicion;
		posicion+=TAMANIO_BYTE_DIN;
		for(int i=0;i<(indice);i++)
		{
			if((TIPO_DATO)indice>cantPres)
			{
				cout<<"La presentacion que quiere borrar no existe"<<endl;
				return;
			}
			if((i+1)==(indice))
				posInicial=posicion;
			//PRESENTACION
			posicion += string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_PRES));
			posicion+=TAMANIO_BYTE_PRES;				
			//PRECIO
			posicion += string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
			posicion+=TAMANIO_BYTE_DIN;			
			//i++;
		}
		dato.replace(posInicial,posicion-posInicial,"");
		strncpy(bloque,dato.c_str(),TAMANIO_BLOQUE_DATO);
		m_archivoDato.seekp(TAMANIO_BLOQUE_DATO* m_nroBloques[nroProducto],ios::beg);
		m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO);

		tamFinal = (TIPO_DATO)strlen(bloque);
		AdministrarEspaciosLibres(tamInicial,tamFinal,TAMANIO_BLOQUE_DATO -(int)strlen(bloque),m_nroBloques[nroProducto]);
		/************************Espacios libres **************************/
		/*
		escribir = (int)::strlen(bloque);

		CClaveEspacioLibre  *espacioAux2 = new CClaveEspacioLibre(escribir ,m_nroBloques[nroProducto]);
		CClavePrimaria		*espacioSecAux = new CClavePrimaria(m_nroBloques[nroProducto]);
		TIPO_DATO blAux=0;
		if(!m_espacioSecDatos.buscar(*espacioSecAux,blAux))
			cout<<"el incide secundario no encontro el dato."<<endl;
		else
		{
			CClaveEspacioLibre  *espacio3 = new CClaveEspacioLibre(espacioSecAux->getNroBloque(),espacioSecAux->getClave());
			m_espacioDatos.eliminarElemVector(*espacio3);
			m_espacioSecDatos.eliminar(*espacioSecAux);
		}
		
		espacioAux2->setClave(TAMANIO_BLOQUE_DATO - escribir );
		//m_espacioDatos.insertar(*espacioAux2);
		m_espacioDatos.insertar(*espacioAux2);
		
			//CClavePrimaria		*espacioSec = new CClavePrimaria(nroBloqueEspacio,espacioAux2->getClave());
		CClavePrimaria		*espacioSec2 = new CClavePrimaria(m_nroBloques[nroProducto],TAMANIO_BLOQUE_DATO - escribir);
		m_espacioSecDatos.insertar(*espacioSec2);
		*/
		/*******************fin de espacios libres ***************************/
	}
	else
		cout<<"No se encontro el dato"<<endl;

}
/*-----------------------------------------------------------*/
void CFichero::eliminar(string &dato,int posicion)
{
	TIPO_DATO cantPres, tamanio;
	
	int posAux=posicion; //guardo la posicion inicial.
	//Salteo todo el producto hasta el siguiente codigo
	posicion+=5;
	//MARCA
	posicion += string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
	posicion+=TAMANIO_BYTE_DIN;			
	//NOMBRE
	posicion += string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
	posicion+=TAMANIO_BYTE_DIN;			
	/*
	//Cantidad de presentaciones
	posicion+=TAMANIO_BYTE_DIN;
	//PRESENTACION
	posicion += string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_PRES));
	posicion+=TAMANIO_BYTE_PRES;	
	//PRECIO
	posicion += string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
	posicion+=TAMANIO_BYTE_DIN;
	*/
	
	//cantidad de presentaciones
	cantPres = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
	posicion+= TAMANIO_BYTE_DIN;
	for(TIPO_DATO j=0;j<cantPres;j++)
	{
		string pres="",precio="";
		//PRESENTACION
		tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_PRES));
		posicion+=TAMANIO_BYTE_PRES;	
		pres =dato.substr(posicion,tamanio);
		posicion+=tamanio;
		//PRECIO
		tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posicion+=TAMANIO_BYTE_DIN;
		precio =dato.substr(posicion,tamanio);
		posicion+=tamanio;	
	}
	string strAux = "";
	int tamDato = 0;
	tamDato = (int)dato.length();
	strAux = dato.substr(posicion, tamDato - posicion);
	dato.erase(posAux,posicion);
	dato += strAux;
}

/*-----------------------------------------------------------*/

void CFichero::eliminarPrimaria(string clave)
{
	CClavePrimaria *primaria = new CClavePrimaria(clave);
	string nombre,marca,strRegAux="";
	int posFinal=0;
	if(m_idxPrimario.eliminar(*primaria)==0)
	{
		cout<<"El elemento que se trato de eliminar, no existe."<<endl;
		return;
	}
	char bloque[TAMANIO_BLOQUE_DATO+1]={};
	string dato;
	int cantLeida;
	int posicion;// posicion en el que encuentra el string
	if(!m_archivoDato.is_open())
		cout<<"El archivo no esta abierto"<<endl;

	m_archivoDato.seekg(TAMANIO_BLOQUE_DATO * (primaria->nroBloque),ios::beg);
	m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO );
	
	this->incrementarCtoProc();//(CTO_PROC)
	
	if(strlen(bloque)==0)
		cout<<"No se leyo nada del archivo de entrada."<<endl;
	if(m_archivoDato.bad())
		cout<<"El archivo es malo"<<endl;
	cantLeida = (int)m_archivoDato.gcount();
	dato.append(bloque);
	if(!buscarDatos(*primaria,dato,posicion))
	{
		cout<<"No se encontro los datos"<<endl;
		return;
	}
	obtenerProximoDatos(primaria->getCodProducto(),dato,posFinal);
	if(posFinal<2)
		posFinal = (int)dato.length();	
	strRegAux +=dato.substr(posicion,posFinal - posicion);

	TIPO_DATO tamInicial, tamFinal;
	tamInicial = (int)dato.length();
	eliminar(dato,posicion);
	strcpy(bloque,dato.c_str());
	dato[0]--;
	m_archivoDato.seekg(TAMANIO_BLOQUE_DATO * (primaria->nroBloque),ios::beg);
	m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO );

	this->incrementarCtoProc();//(CTO_PROC)
	
	//elimino las otras claves que dependen de la clave primaria.
//	this->eliminarClaves(clave,CLAVE_SEC_NOMBRE|CLAVE_SEC_MARCA|CLAVE_CANDIDATA);
	this->eliminarClaves(strRegAux,CLAVE_SEC_NOMBRE|CLAVE_SEC_MARCA|CLAVE_CANDIDATA);//(J1124)
	
	/*MANEJO DE ESPACIOS LIBRES*/
	TIPO_DATO nuevoEspLibre ;
	tamFinal = (TIPO_DATO)strlen(bloque);
	nuevoEspLibre = TAMANIO_BLOQUE_DATO -(TIPO_DATO)strlen(bloque);

	AdministrarEspaciosLibres(tamInicial,tamFinal,nuevoEspLibre,primaria->getNroBloque());	
}

/*-----------------------------------------------------------*/
void CFichero::eliminarCandidata(string registro)
{
	TIPO_DATO tamInicial,tamFinal;
	CClaveCandidata *candidata = new CClaveCandidata(registro);
	char bloque[TAMANIO_BLOQUE_DATO+1]={};
	string dato,strRegAux="";
	int cantLeida,posFinal;
	int posicion;// posicion en el que encuentra el string

	if(m_idxCandidata.eliminar(*candidata)==0)
	{
		cout<<"El elemento que se trato de eliminar, no existe."<<endl;
		return;
	}
	registro = itoa(candidata->getCodProducto()) + convertirChar((TIPO_DATO)candidata->getNombre().length(),TAMANIO_BYTE_DIN) +candidata->getNombre();
	registro += convertirChar((TIPO_DATO)candidata->getMarca().length(),TAMANIO_BYTE_DIN) +candidata->getMarca();
	CClavePrimaria *primaria = new CClavePrimaria(candidata->getCodProducto());
	if(m_idxPrimario.eliminar(*primaria)==0)
		cout<<"El elemento que se trato de eliminar, no existe."<<endl;

	if(!m_archivoDato.is_open())
		cout<<"El archivo no esta abierto"<<endl;

	m_archivoDato.seekg(TAMANIO_BLOQUE_DATO * (primaria->nroBloque),ios::beg);
	m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO );
	
	this->incrementarCtoProc();//(CTO_PROC)
		
	if(strlen(bloque)==0)
		cout<<"No se leyo nada del archivo de entrada."<<endl;
	if(m_archivoDato.bad())
		cout<<"El archivo es malo"<<endl;	
	cantLeida = (int)m_archivoDato.gcount();
	dato.append(bloque);
	tamInicial = (TIPO_DATO)dato.length();


	if(!buscarDatos(*primaria,dato,posicion))
	{
		cout<<"No se encontro los datos"<<endl;
		return;
	}
	obtenerProximoDatos(primaria->getCodProducto(),dato,posFinal);
	if(posFinal<2)
		posFinal = (int)dato.length();	
	strRegAux +=dato.substr(posicion,posFinal - posicion);
	
	eliminar(dato,posicion);
	strcpy(bloque,dato.c_str());
	dato[0]--;
	m_archivoDato.seekg(TAMANIO_BLOQUE_DATO * (primaria->nroBloque),ios::beg);
	m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO );
	
	this->incrementarCtoProc(); //(CTO_PROC)
		
	//mostrar(bloque);

	//elimino las otras claves que dependen de la clave primaria.
	//this->eliminarClaves(registro,CLAVE_SEC_NOMBRE|CLAVE_SEC_MARCA);
	this->eliminarClaves(strRegAux/*registro*/,CLAVE_SEC_NOMBRE|CLAVE_SEC_MARCA); 
	
	/*MANEJO DE ESPACIOS LIBRES*/
	TIPO_DATO nuevoEspLibre ;
	tamFinal = (TIPO_DATO)strlen(bloque);
	nuevoEspLibre = TAMANIO_BLOQUE_DATO -(TIPO_DATO)strlen(bloque);

	AdministrarEspaciosLibres(tamInicial,tamFinal,nuevoEspLibre,primaria->getNroBloque());	

}
/*-----------------------------------------------------------*/
void CFichero::eliminarSecNombre(string registro)
{
	TIPO_DATO tamFinal=0,tamInicial=0;
	int posFinal;
	string strRegAux="";
	CClaveSecundaria *secundaria= new CClaveSecundaria(registro);
	if(m_idxSecNombre.eliminar(*secundaria)==0)
	{
		cout<<"El elemento que se trato de eliminar, no existe."<<endl;
		return;
	}
	list<TIPO_DATO>				lista;
	list<TIPO_DATO>::iterator	it;
	obtenerLista(m_idxSecNombre.getArchivo(),*secundaria,lista);
	for(it=lista.begin();it!=lista.end();it++)
	{

		CClavePrimaria *primaria = new CClavePrimaria((*it));
		if(m_idxPrimario.eliminar(*primaria)==0)
			cout<<"El elemento que se trato de eliminar, no existe."<<endl;

		char bloque[TAMANIO_BLOQUE_DATO+1]={};
		string dato;
		int cantLeida;
		int posicion;// posicion en el que encuentra el string
		if(!m_archivoDato.is_open())
			cout<<"El archivo no esta abierto"<<endl;

		m_archivoDato.seekg(TAMANIO_BLOQUE_DATO * (primaria->nroBloque),ios::beg);
		m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO );
		
		this->incrementarCtoProc(); //(CTO_PROC)
			
		if(strlen(bloque)==0)
			cout<<"No se leyo nada del archivo de entrada."<<endl;
		if(m_archivoDato.bad())
			cout<<"El archivo es malo"<<endl;
		cantLeida = (int)m_archivoDato.gcount();
		dato.append(bloque);



		if(!buscarDatos(*primaria,dato,posicion))
		{
			cout<<"No se encontro los datos"<<endl;
			return;
		}
		obtenerProximoDatos(primaria->getCodProducto(),dato,posFinal);
		if(posFinal<2)
			posFinal = (int)dato.length();	
		//strRegAux +=dato.substr(posicion,posFinal - posicion);
		strRegAux =dato.substr(posicion,posFinal - posicion);
		
		eliminar(dato,posicion);
		strcpy(bloque,dato.c_str());
		dato[0]--;
		m_archivoDato.seekg(TAMANIO_BLOQUE_DATO * (primaria->nroBloque),ios::beg);
		m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO );
		
		this->incrementarCtoProc(); //(CTO_PROC)
				
		//mostrar(bloque);		

		//elimino las otras claves que dependen de la clave primaria.
		this->eliminarClaves(strRegAux,CLAVE_CANDIDATA|CLAVE_SEC_MARCA);
		/*MANEJO DE ESPACIOS LIBRES*/
		TIPO_DATO nuevoEspLibre ;
		tamFinal = (TIPO_DATO)strlen(bloque);
		nuevoEspLibre = TAMANIO_BLOQUE_DATO -(TIPO_DATO)strlen(bloque);

		AdministrarEspaciosLibres(tamInicial,tamFinal,nuevoEspLibre,primaria->getNroBloque());	

	}
}
/*-----------------------------------------------------------*/
void CFichero::eliminarSecMarca(string registro)
{
	TIPO_DATO tamFinal=0,tamInicial=0;
	int posFinal;
	string strRegAux="";
	CClaveSecundaria *secundaria= new CClaveSecundaria(registro,false);
	if(m_idxSecMarca.eliminar(*secundaria)==0)
	{
		cout<<"El elemento que se trato de eliminar, no existe."<<endl;
		return;
	}
	list<TIPO_DATO>				lista;
	list<TIPO_DATO>::iterator	it;
	obtenerLista(m_idxSecMarca.getArchivo(),*secundaria,lista);
	for(it=lista.begin();it!=lista.end();it++)
	{

		CClavePrimaria *primaria = new CClavePrimaria((*it));
		if(m_idxPrimario.eliminar(*primaria)==0)
		{
			cout<<"El elemento que se trato de eliminar, no existe."<<endl;
		}

		char bloque[TAMANIO_BLOQUE_DATO+1]={};
		string dato;
		int cantLeida;
		int posicion;// posicion en el que encuentra el string
		if(!m_archivoDato.is_open())
			cout<<"El archivo no esta abierto"<<endl;

		m_archivoDato.seekg(TAMANIO_BLOQUE_DATO * (primaria->nroBloque),ios::beg);
		m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO );
		
		this->incrementarCtoProc(); //(CTO_PROC)
				
		if(strlen(bloque)==0)
			cout<<"No se leyo nada del archivo de entrada."<<endl;
		if(m_archivoDato.bad())
			cout<<"El archivo es malo"<<endl;
		cantLeida = (int)m_archivoDato.gcount();
		dato.append(bloque);


		if(!buscarDatos(*primaria,dato,posicion))
		{
			cout<<"No se encontro los datos"<<endl;
			return;
		}
		obtenerProximoDatos(primaria->getCodProducto(),dato,posFinal);
		if(posFinal<2)
			posFinal = (int)dato.length();	
		//strRegAux +=dato.substr(posicion,posFinal - posicion);
		strRegAux =dato.substr(posicion,posFinal - posicion);
		
		eliminar(dato,posicion);
		strcpy(bloque,dato.c_str());
		dato[0]--;
		m_archivoDato.seekg(TAMANIO_BLOQUE_DATO * (primaria->nroBloque),ios::beg);
		m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO );
		
		this->incrementarCtoProc(); //(CTO_PROC)
		//mostrar(bloque);		

		//elimino las otras claves que dependen de la clave primaria.
		this->eliminarClaves(strRegAux,CLAVE_CANDIDATA|CLAVE_SEC_NOMBRE);
		/*MANEJO DE ESPACIOS LIBRES*/
		TIPO_DATO nuevoEspLibre ;
		tamFinal = (TIPO_DATO)strlen(bloque);
		nuevoEspLibre = TAMANIO_BLOQUE_DATO -(TIPO_DATO)strlen(bloque);

		AdministrarEspaciosLibres(tamInicial,tamFinal,nuevoEspLibre,primaria->getNroBloque());	

	}

}
/*-----------------------------------------------------------*/
void CFichero::buscar(string registro)
{
}
void CFichero::insertarDatos(string registro,TIPO_DATO &nroBloque,bool leer)
{
	int leidos;
	char bloque[TAMANIO_BLOQUE_DATO+1]={};
		if(leer && m_tamanioArch!=1 /*&& getNroBloque()<=nroBloque*/)
		{
			TIPO_DATO espacioLibre ;
			//nroBloque =  primaria->nroBloque;
			m_archivoDato.seekg(TAMANIO_BLOQUE_DATO*(nroBloque),ios::beg);
			m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO);
			
			espacioLibre = TAMANIO_BLOQUE_DATO -(TIPO_DATO)strlen(bloque);
			if(nroBloque ==getNroBloque() && espacioLibre != espacioLibreAntiguo)
				cout<<"ESTAMAL !!!!!!!!"<<endl;
			/*voy a resolver el caso en que al querer agregar un nuevo registro verifique denuevo que este pueda entrar*/
			if(espacioLibre >= (TIPO_DATO)registro.length())
			{										
				leidos = m_archivoDato.gcount();
				if(m_archivoDato.bad())
					cout<<endl;
				
				cargarBloque(bloque,registro);	
				bloque[0]++;	//incremento la cantidad de registros del bloque
				if(nroBloque ==getNroBloque())
				m_tamanioArch += (int)registro.length();					
			}
			else
			{
				char bloqueAux[TAMANIO_BLOQUE_DATO+1]={};
				//se supone que este es un nuevo nodo.
				//Cuando sepa inicializar el vector cambiar este pedazo de codigo
				//for(int i=0;i<5;i++)
				//	bloque[i]='\0';
				//////
				if((int)registro.length()>=TAMANIO_BLOQUE_DATO)
					cout<<"Este caso todavia no lo resolvimos!!!!!!"<<endl;
				++nroBloque;
				m_tamanioArch = TAMANIO_BLOQUE_DATO*nroBloque+1;
				bloqueAux[0]=(char)1; //cantidad de registros			
				cargarBloque(bloqueAux,registro);
				m_tamanioArch += (int)registro.length();				
				strncpy(bloque,bloqueAux,TAMANIO_BLOQUE_DATO);
			}
		}
		else
		{
			bloque[0]=(char)1; //cantidad de registros			
			cargarBloque(bloque,registro);
			m_tamanioArch += (int)registro.length();
		}

//		cout<<"CANTIDAD REGISTROS : "<<(TIPO_DATO)bloque[0]<< " NUMERO DE BLOQUE : "<<nroBloque<<endl;
//		if( nroBloque == (unsigned long)1908)
//			cout<<"Va a escribir el bloque 1908."<<endl;		
		m_archivoDato.seekp(TAMANIO_BLOQUE_DATO*nroBloque,ios::beg);
//		aux1 = m_archivoDato.tellg();
//		aux2 = (TAMANIO_BLOQUE_DATO*nroBloque);
//		if(aux1 != aux2)
//			cout<<"El seekg no funco!!!!!!!!"<<endl;
		m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO);
		
		this->incrementarCtoProc(); //(CTO_PROC)
		
		if(m_archivoDato.bad())
				cout<<endl;
	//	mostrar(bloque);

//		m_archivoDato.flush();
}
/*-----------------------------------------------------------*/
void CFichero::insertar(string registro)
{
	bool leer=false;
	//int leidos;
	TIPO_DATO cantAEscribir=0,nroBloqueAnt,nroBloque=0,cantOcupada=0,espacioLibre=0,tamArchAnt;//, aux1, aux2; //cantidad ocupada en el bloque incompleto
	tamArchAnt = m_tamanioArch;
	cantOcupada = m_tamanioArch%TAMANIO_BLOQUE_DATO;
	espacioLibreAntiguo=espacioLibre = TAMANIO_BLOQUE_DATO - cantOcupada ;
	char bloque[TAMANIO_BLOQUE_DATO+1]={};
	nroBloqueAnt=nroBloque = getNroBloque(); //del archivo de datos
	cantAEscribir = (TIPO_DATO)registro.length();
	if((cantAEscribir+1)>=TAMANIO_BLOQUE_DATO)
	{
		cout<<"* * * * * SE QUISO PONER UN REGISTRO DE MAYOR TAMANIO DEL QUE ENTRA EN UN BLOQUE."<<endl;
		return;
	}
	if((espacioLibre > cantAEscribir)&&(cantOcupada > 0))
		leer=true; //debe leer el bloque porque este reg entra en el
//	else if (cantOcupada > 0)
	else if (m_tamanioArch > 0)
		{
			nroBloque++;
			m_tamanioArch = nroBloque*TAMANIO_BLOQUE_DATO+1;
			cout<<"* * * ULTIMO NRO DE BLOQUE DE DATOS: "<<nroBloque<<endl;			
	//		CClaveEspacioLibre  *espacioNuevo = new CClaveEspacioLibre(TAMANIO_BLOQUE_DATO-1,nroBloque);
	//		CClavePrimaria		*espacioSecNew = new CClavePrimaria(nroBloque);
	//		TIPO_DATO blAux=0;
	//		if(!m_espacioSecDatos.buscar(*espacioSecNew,blAux))			
	//			m_espacioDatos.insertar(*espacioNuevo);
			
			

		}
	TIPO_DATO nroBloqueEspacio=0;

	CClavePrimaria *primaria = new CClavePrimaria(registro,nroBloque);
	CClavePrimaria *primariaIn = new CClavePrimaria(registro,nroBloque);

	if(nroBloque>=97)
		cout<<"Llego a la clave esperada"<<endl;
	
	if(primaria->getClave()==20597 && nroBloque>=97)
		cout<<"Llego a la clave esperada"<<endl;
		
	this->inicializarCtoProc(); //(CTO_PROC)
		
	if(m_idxPrimario.insertar(*primaria))
	{
		TIPO_DATO nuevoEspLib;
	//	CClaveSecundariaSec *secNombreSec = new CClaveSecundariaSec(registro);
	//	CClaveSecundariaSec *secMarcaSec = new CClaveSecundariaSec(registro,false);

	//	CClaveCandidata		*candidata = new CClaveCandidata(registro);
	//	CClaveSecundaria	*secNombre = new CClaveSecundaria(registro);//secundaria del nombre
	//	CClaveSecundaria	*secMarca = new CClaveSecundaria(registro,false);//secundaria del Marca


		CClaveEspacioLibre  *espacio = new CClaveEspacioLibre(cantAEscribir,primariaIn->getCodProducto());		
		if(m_espacioDatos.obtenerNroBloque(*espacio,nroBloqueEspacio))
		{
            CClavePrimaria		*espacioSec = new CClavePrimaria(nroBloqueEspacio);
			m_espacioSecDatos.eliminar(*espacioSec);
			nroBloque = nroBloqueEspacio;
			if(tamArchAnt != (TIPO_DATO)this->m_tamanioArch)
			{
				m_tamanioArch = tamArchAnt ;
				//nroBloque--;
			}
		//	if(encontro)
			leer = true;
			nuevoEspLib = espacio->getClave()-cantAEscribir;
		}
		else//esto seria un nuevo nodo
		{
				if(leer)
				{
					nroBloque++;
					m_tamanioArch = nroBloque*TAMANIO_BLOQUE_DATO+1;
					espacio->setNroBloque(nroBloque);
					leer=false;
				}
				nuevoEspLib =  TAMANIO_BLOQUE_DATO -cantAEscribir;
			//	espacio->setClave(espacioLibreAux );
			//nuevoEspLib = TAMANIO_BLOQUE_DATO - cantAEscribir -1;
		}
		if(nroBloque != primariaIn->getNroBloque())
		{
			CClavePrimaria *primNueva = new CClavePrimaria(registro,nroBloque);
			m_idxPrimario.cambiarClave(*primariaIn,*primNueva);
		}

//		m_idxCandidata.insertar(*candidata);

//		m_idxSecNombre.insertar(*secNombre);
//		m_idxSecNombreSec.insertar(*secNombreSec);
		
//		m_idxSecMarca.insertar(*secMarca);		
//		m_idxSecMarcaSec.insertar(*secMarcaSec);


		insertarDatos(registro,nroBloque,leer);
		//if(nroBloque != primaria->getNroBloque())
		if(nroBloque < nroBloqueAnt)
			m_tamanioArch = tamArchAnt;
		CClaveEspacioLibre  *espacioaux = new CClaveEspacioLibre(nuevoEspLib,nroBloque);
		m_espacioDatos.insertar(*espacioaux);
		
		CClavePrimaria		*espacioSec = new CClavePrimaria(nroBloque,nuevoEspLib);
		m_espacioSecDatos.insertar(*espacioSec);
		
		
		//m_tamanioArch += (int)registro.length();	
	}
	else //el codigo  ya fue ingresado entonces es una presentacion y precio nuevo
	{
		CClavePrimaria primAux;
		int posReg=0,escribir=0;
		//bool escribir=false;
		string dato="",strRegAux="";
		int posicion=0,posFinal=0;
		cantAEscribir=0;
		//codigo de producto
		moverHastaCantPresentacion(registro,posReg);
		//Cantidad de presentaciones.
		posReg+=TAMANIO_BYTE_DIN;
		cantAEscribir = (int)registro.length() - posReg;

		primAux = *primaria;//m_idxPrimario.getClaveAux();
		m_archivoDato.seekg(TAMANIO_BLOQUE_DATO*(primAux.getNroBloque()),ios::beg);
		m_archivoDato.read(bloque,TAMANIO_BLOQUE_DATO);			
		if(m_archivoDato.bad())
			cout<<"El archivo es malo"<<endl;
			
		espacioLibre = TAMANIO_BLOQUE_DATO -(TIPO_DATO)strlen(bloque);
		if(nroBloque ==primAux.getNroBloque() && espacioLibre != espacioLibreAntiguo)
			cout<<"ESTAMAL !!!!!!!!"<<endl;

//		dato.append(bloque);
		if((espacioLibre < cantAEscribir)/*&&(cantOcupada > 0)*/)
		{
			char bloqueAux[TAMANIO_BLOQUE_DATO+1]={};
			string dato="";
		//	escribir=true; //debe leer el bloque porque este reg entra en el
			dato.append(bloque);
			if(!buscarDatos(primAux,dato,posicion))
			{
				cout<<"No se encontro los datos"<<endl;
				return;
			}
			obtenerProximoDatos(primAux.getCodProducto(),dato,posFinal);
			if(posFinal<2)
				posFinal = (int)dato.length();
			strRegAux=convertirChar(0,TAMANIO_BYTE_DIN);
			strRegAux +=dato.substr(posicion,posFinal - posicion);

//registro.substr(posReg,cantAEscribir)

			//CAMBIAR LA CLAVE PRIMARIA POR HABER CAMBIADO EL NUMERO DE BLOQUE DEL REGISTRO.
			//VER ARIEL
			
			cargarPresentacion(strRegAux,registro);
			strncpy(bloqueAux,strRegAux.c_str(),TAMANIO_BLOQUE_DATO);   			
			incCantPresentacion(primAux,bloqueAux);
			strRegAux="";
			strRegAux.append(bloqueAux);
			strRegAux.replace(0,1,"");//lo vuelvo registro para usar la funcion insertar datos
			//MANEJO DE ESPACIO LIBRES
			
			TIPO_DATO espacioLibreAux;
			bool encontro=false;
			CClaveEspacioLibre  *espacio = new CClaveEspacioLibre((int)strRegAux.length(),nroBloque);
			if(m_espacioDatos.obtenerNroBloque(*espacio,nroBloqueEspacio))
			{
				encontro=true;
				if(nroBloqueEspacio<nroBloque)
				{
					if(!leer)
						m_tamanioArch = tamArchAnt;
					leer=true;
				}
				nroBloque = nroBloqueEspacio;
				//espacio->setClave( espacioLibre -(int)strRegAux.length());
				espacioLibreAux =  espacio ->getClave()-(int)strRegAux.length();
				espacio->setClave(espacioLibreAux );
	            CClavePrimaria		*espacioSec = new CClavePrimaria(nroBloqueEspacio);
				m_espacioSecDatos.eliminar(*espacioSec);
				//leer = true;
			}
			else
			{
				if(leer)
				{
					nroBloque++;
					m_tamanioArch = nroBloque*TAMANIO_BLOQUE_DATO+1;
					espacio->setNroBloque(nroBloque);
					leer=false;
				}
				espacioLibreAux =  TAMANIO_BLOQUE_DATO -(int)strRegAux.length();
				espacio->setClave(espacioLibreAux );
			}

			if(nroBloque != primaria->getNroBloque())
			{
				CClavePrimaria *primNueva = new CClavePrimaria(registro,nroBloque);
				m_idxPrimario.cambiarClave(primAux,*primNueva);
			}
		if(m_archivoDato.bad())
			cout<<"El archivo es malo"<<endl;

			insertarDatos(strRegAux,nroBloque,leer);	
		if(m_archivoDato.bad())
			cout<<"El archivo es malo"<<endl;

			/*si es diferente quiere decir que dentro del insertar escribio en otro bloque por que no entraba donde debia ir*/
			/*el nuevo registro entra en un nodo nuevo*/
			//if(nroBloque!=espacio->getCodProducto(0))
			if(nroBloque>nroBloqueEspacio && encontro)
			{
				//VER SI VA ESTO  espacioLibreAux = TAMANIO_BLOQUE_DATO -(int)strRegAux.length();
				espacio->setClave( TAMANIO_BLOQUE_DATO -(int)strRegAux.length());
				espacio->setNroBloque(nroBloque);
				CClavePrimaria *primNueva = new CClavePrimaria(strRegAux,nroBloque);
				m_idxPrimario.cambiarClave(primAux,*primNueva);

			}
			//espacio->setNroBloque(nroBloque);
			//VER ARIEL
			/*TENGO QUE RESOLVER EL CASO EN QUE ALLA INCREMENTADO EL BLOQUE EN INSERTARDATOS*/
	//		if(nroBloque != primAux.getNroBloque())
	//			m_tamanioArch = tamArchAnt;
//			if(nroBloque != nroBloqueAnt)
//				m_tamanioArch = tamArchAnt;

			m_espacioDatos.insertar(*espacio);
			
			CClavePrimaria		*espacioSec = new CClavePrimaria(nroBloque,espacioLibreAux);
			m_espacioSecDatos.insertar(*espacioSec);
			
//			CClavePrimaria *primNueva = new CClavePrimaria(strRegAux,nroBloque);
//			m_idxPrimario.cambiarClave(primAux,*primNueva);

		//	m_tamanioArch += (int)strRegAux.length();	

			if((posFinal - posicion)==0)
				cout<<"TENGO QQUE TERMINAR ESTE CASO!!!!!!!!!!!"<<endl;
			dato.replace(posicion,posFinal-posicion,"");
			strncpy(bloque,dato.c_str(),TAMANIO_BLOQUE_DATO); 
			bloque[0]--;  
			escribir = (int)::strlen(bloque);

			CClaveEspacioLibre  *espacioAux2 = new CClaveEspacioLibre(escribir ,primAux.getNroBloque());
			CClavePrimaria		*espacioSecAux = new CClavePrimaria(primAux.getNroBloque());
			TIPO_DATO blAux=0;
			if(!m_espacioSecDatos.buscar(*espacioSecAux,blAux))
				cout<<"el incide secundario no encontro el dato."<<endl;
			else
			{
				CClaveEspacioLibre  *espacio3 = new CClaveEspacioLibre(espacioSecAux->getNroBloque(),espacioSecAux->getClave());
				m_espacioDatos.eliminarElemVector(*espacio3);
				m_espacioSecDatos.eliminar(*espacioSecAux);
			}
			
			espacioAux2->setClave(TAMANIO_BLOQUE_DATO - escribir );
			//m_espacioDatos.insertar(*espacioAux2);
			m_espacioDatos.insertar(*espacioAux2);
			
				//CClavePrimaria		*espacioSec = new CClavePrimaria(nroBloqueEspacio,espacioAux2->getClave());
			CClavePrimaria		*espacioSec2 = new CClavePrimaria(primAux.getNroBloque(),TAMANIO_BLOQUE_DATO - escribir);
			m_espacioSecDatos.insertar(*espacioSec2);
			

		}
		else
		{
			//Tengo que ver si todo el registro con las presentaciones entran en el bloque de datos.
			//de no ser asi tendria que ponerlo en un bloque nuevo contiguo al bloque
			//VER JHONNY
			TIPO_DATO nuevoEspLibre;
			cargarPresentacion(bloque,registro);
			if(primAux.getNroBloque()==nroBloque)
				m_tamanioArch += cantAEscribir;
			else
				{
					if(primAux.getNroBloque()==(nroBloque-1))
					{
						
						if(!leer)
						{
							m_tamanioArch =tamArchAnt+cantAEscribir;
							--nroBloque;
						}
					}
					else if(!leer)
							m_tamanioArch =tamArchAnt;
				}
			incCantPresentacion(primAux,bloque);							
			escribir = cantAEscribir ;


			nuevoEspLibre = TAMANIO_BLOQUE_DATO -(TIPO_DATO)strlen(bloque);
			CClaveEspacioLibre  *espacio = new CClaveEspacioLibre(nuevoEspLibre ,primAux.getNroBloque());
//			m_espacioDatos.obtenerNroBloque(*espacio,nroBloqueEspacio);
	//		CClaveEspacioLibre  *espacioAux2 = new CClaveEspacioLibre(escribir ,primAux.getNroBloque());
			CClavePrimaria		*espacioSecAux = new CClavePrimaria(primAux.getNroBloque());
			TIPO_DATO blAux=0;
			if(!m_espacioSecDatos.buscar(*espacioSecAux,blAux))
				cout<<"el incide secundario no encontro el dato."<<endl;
			else
			{
				CClaveEspacioLibre  *espacio3 = new CClaveEspacioLibre(espacioSecAux->getNroBloque(),espacioSecAux->getClave());
				m_espacioDatos.eliminarElemVector(*espacio3);
				m_espacioSecDatos.eliminar(*espacioSecAux);
			}

			espacio->setClave(TAMANIO_BLOQUE_DATO - (TIPO_DATO)strlen(bloque) );
//			espacio->setClave(espacioLibre - escribir );
			m_espacioDatos.insertar(*espacio);
			
			CClavePrimaria		*espacioSec = new CClavePrimaria(primAux.getNroBloque(),TAMANIO_BLOQUE_DATO - (TIPO_DATO)strlen(bloque));
			m_espacioSecDatos.insertar(*espacioSec);
			
			
		}		
		
		if(m_archivoDato.bad())
			cout<<"El archivo es malo"<<endl;
		if(primAux.getNroBloque()==3)
			cout<<"Este bloque tiene problemas!!!"<<endl;

		//incCantPresentacion(primAux,bloque);
		m_archivoDato.seekp(TAMANIO_BLOQUE_DATO*primAux.getNroBloque(),ios::beg);
		m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO);
		//mostrar(bloque);
		if(m_archivoDato.bad())
			cout<<"El archivo es malo"<<endl;

	}
}
/*-----------------------------------------------------------*/
void CFichero::incCantPresentacion(CClavePrimaria primaria,char bloque[])
{
	int posicion;
	string dato="";
	dato.append(bloque);
	buscarDatos(primaria,dato,posicion);
	moverHastaCantPresentacion(dato,posicion);
	bloque[posicion]++;
}

/*-----------------------------------------------------------*/
void CFichero::moverHastaCantPresentacion(string registro,int &posReg)
{
	//codigo de producto
	posReg+=5;
	//MARCA
	posReg+= string2TipoDato(registro.substr(posReg,TAMANIO_BYTE_DIN));
	posReg+=TAMANIO_BYTE_DIN;					
	//NOMBRE
	posReg+= string2TipoDato(registro.substr(posReg,TAMANIO_BYTE_DIN));
	posReg+=TAMANIO_BYTE_DIN;			
	//Cantidad de presentaciones.
	//registro[posReg]++;//incremento la cantidad de presentaciones
	//posReg+=TAMANIO_BYTE_DIN;
}
/*-----------------------------------------------------------*/
void CFichero::cargarPresentacion(char bloque[],string registro)
{
	TIPO_DATO codProd=0;	
	char numero[2]={};
	int posicion=0,posReg=0;
	string strAux="",strBloque;
	strBloque.append(bloque);	
	numero[0] = bloque[0]; //copio la cantidad de registros del bloque
	numero[1]='\0';
	strAux.append(numero);	

	moverHastaCantPresentacion(registro,posReg);
	posReg+=TAMANIO_BYTE_DIN;

	codProd = atoi(registro.substr(0,5).c_str());
	if((int)strlen(bloque)>2)
		obtenerProximoDatos(codProd,strBloque,posicion);	
	if(posicion>1)
		strAux += strBloque.substr(1,posicion-1);
	strAux += registro.substr(posReg,(int)registro.length() - posReg); //inserto el reg de forma ordenada
//	verificacion = (int)strBloque.length();
//	strcat(bloque,strBloque.substr(posicion,((int)strBloque.length()) -posicion).c_str());//copio los registro con codigos mayores
	if(/*(2*posicion )!= ((int)strBloque.length())  &&*/ ((int)strBloque.length())>2 && (posicion )!= ((int)strBloque.length())  )
		strAux += strBloque.substr(posicion,((int)strBloque.length()) -posicion);
//	if((int)strAux.length()>=TAMANIO_BLOQUE_DATO)
//		if(strAux.c_str()[TAMANIO_BLOQUE_DATO]=='\0')
//			strAux.erase(TAMANIO_BLOQUE_DATO,1);
//	mostrar(bloque);	
	strncpy(bloque,strAux.c_str(),TAMANIO_BLOQUE_DATO);  
	
}
/*-----------------------------------------------------------*/
void CFichero::cargarPresentacion(string &strBloque,string registro)
{
	TIPO_DATO codProd=0;	
	char numero[2]={};
	int posicion=0,posReg=0;
	string strAux="";
	//strBloque.append(bloque);	
	numero[0] = strBloque[0]; //copio la cantidad de registros del bloque
	numero[1]='\0';
	strAux.append(numero);	

	moverHastaCantPresentacion(registro,posReg);
	posReg+=TAMANIO_BYTE_DIN;

	codProd = atoi(registro.substr(0,5).c_str());
	if((int)strBloque.length()>2)
		obtenerProximoDatos(codProd,strBloque,posicion);	
	if(posicion>1)
		strAux += strBloque.substr(1,posicion-1);
	strAux += registro.substr(posReg,(int)registro.length() - posReg); //inserto el reg de forma ordenada
//	verificacion = (int)strBloque.length();
//	strcat(bloque,strBloque.substr(posicion,((int)strBloque.length()) -posicion).c_str());//copio los registro con codigos mayores
	if(/*(2*posicion )!= ((int)strBloque.length())  &&*/ ((int)strBloque.length())>2 && (posicion )!= ((int)strBloque.length())  )
		strAux += strBloque.substr(posicion,((int)strBloque.length()) -posicion);
		
	//strncpy(bloque,strAux.c_str(),TAMANIO_BLOQUE_DATO);
	strBloque = strAux;
}

/*-----------------------------------------------------------*/
void CFichero::cargarBloque(char bloque[],string registro)
{
	TIPO_DATO codProd=0;	
	char numero[2]={};
	int posicion=0,verificacion;
	string strAux="",strBloque;
	strBloque.append(bloque);	
	numero[0] = bloque[0]; //copio la cantidad de registros del bloque
	numero[1]='\0';
	strAux.append(numero);	
	codProd = atoi(registro.substr(0,5).c_str());
	if((int)strlen(bloque)>2)
		obtenerProximoDatos(codProd,strBloque,posicion);	
	if(posicion>1)
		strAux += strBloque.substr(1,posicion-1);
//	strcat(bloque,strBloque.substr(0,posicion-1).c_str());//copio los registro con codigos menores
	//strcat(bloque,registro.c_str());//copio el codigo
	strAux += registro; //inserto el reg de forma ordenada
	verificacion = (int)strBloque.length();
//	strcat(bloque,strBloque.substr(posicion,((int)strBloque.length()) -posicion).c_str());//copio los registro con codigos mayores
	if(/*(2*posicion )!= ((int)strBloque.length())  &&*/ ((int)strBloque.length())>2 && (posicion )!= ((int)strBloque.length())  )
		strAux += strBloque.substr(posicion,((int)strBloque.length()) -posicion);
		
	strncpy(bloque,strAux.c_str(),TAMANIO_BLOQUE_DATO);  
}
/*-----------------------------------------------------------*/
void CFichero::eliminar(string registro)
{
}
/*-----------------------------------------------------------*/
void CFichero::recorrer(string registro)
{
}
/*-----------------------------------------------------------*/
string CFichero::generaMarca(string &numMarca)
{	
	int marca;
	numMarca="";
	marca = 1 + rand()%30;	
	if (marca<10)
		numMarca="0";
	numMarca += itoa(marca);
	return m_marcas[marca];
}
/*-----------------------------------------------------------*/
string CFichero::generaNombre()
{
	int nombre;
	string aux="";
	char carAux[3]={};
	carAux[0] = '0';
	carAux[1] = '0'; 
	carAux[2] = '\0';	
	
	nombre = 1 + rand()%999;
	if(nombre<10)
	{
		//carAux[1] = '\0';
		aux.append(carAux);
	}
	else
		if(nombre<100)
		{
			carAux[1] = '\0';
			aux.append(carAux);
		}
	aux += itoa(nombre);
	return aux;	
}
/*-----------------------------------------------------------*/
string CFichero::generaPresenetacion()
{	//El formato es PX**...*** donde X es la cantidad 
	//de * que vienen a continuacion
	int presentacion;
	string aux="";
	presentacion = 1 + rand()% TAMANIO_PRESENTACION;
	aux = "P"+itoa(presentacion);
	for(int i=0; i < presentacion; i++)
		aux += "*";
	
	return aux;
}
/*-----------------------------------------------------------*/
string CFichero::generaPrecio()
{
	int entero, decimal;
	entero = rand()%10000;
	decimal = rand()%100;
	
	return itoa(entero)+"."+itoa(decimal);
}
/*-----------------------------------------------------------*/
void CFichero::obtenerProximo(TIPO_DATO codProd,string dato,int& posicion)
{
	bool encontrado=false;
	int cantReg,i=0,tamanio=0;
	TIPO_DATO codigoAux,cantPres;
	string strcodProd="";
	posicion=0;
	cantReg = (unsigned char)(dato.substr(posicion,TAMANIO_CANTIDAD_REGISTRO).c_str()[0]);
	if(cantReg == 0)
		posicion = 0;
	posicion += TAMANIO_CANTIDAD_REGISTRO;
	while(i<cantReg && !encontrado)
	{	//CODIGO
		strcodProd = dato.substr(posicion,5); 
		codigoAux = atoi(strcodProd .c_str());
		if(codProd<codigoAux)
			return;	
		else if((i+1)==cantReg)//es el ultimo y el codigo sigue siendo el mayir
			return;
		//Salteo todo el producto hasta el siguiente codigo
		posicion+=5;
		//MARCA
		tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posicion+=TAMANIO_BYTE_DIN;			
		posicion+=tamanio;
		//NOMBRE
		tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posicion+=TAMANIO_BYTE_DIN;			
		posicion+=tamanio;
		
		//cantidad de presentaciones
		cantPres = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posicion+= TAMANIO_BYTE_DIN;
		for(unsigned int j=0;j<cantPres;j++)
		{
			//PRESENTACION
			tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_PRES));
			posicion+=TAMANIO_BYTE_PRES;	
			posicion+=tamanio;
			//PRECIO
			tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
			posicion+=TAMANIO_BYTE_DIN;
			posicion+=tamanio;	
		}
		++i;		
	}
}
/*-----------------------------------------------------------*/
void CFichero::obtenerProximoDatos(TIPO_DATO codProd,string dato,int& posicion)
{
	bool encontrado=false;
	int cantReg,i=0,tamanio=0,cantPres=0;
	TIPO_DATO codigoAux;
	string strcodProd="";
	posicion=0;
	cantReg = (unsigned char)(dato.substr(posicion,TAMANIO_CANTIDAD_REGISTRO).c_str()[0]);
	if(cantReg ==0)
		posicion=0;
	posicion +=TAMANIO_CANTIDAD_REGISTRO;
	while(i<cantReg && !encontrado)
	{
		strcodProd = dato.substr(posicion,5); 
		codigoAux = atoi(strcodProd .c_str());
		if(codProd<codigoAux)
			return;	
		
		posicion+=5;
		//MARCA
		tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));//LONGITUD
		posicion+=TAMANIO_BYTE_DIN;	//saltea el indicador de cual es la longitud
		strcodProd =dato.substr(posicion,tamanio); //para verificar
		posicion+=tamanio;
		//NOMBRE
		tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posicion+=TAMANIO_BYTE_DIN;			
		strcodProd =dato.substr(posicion,tamanio);
		posicion+=tamanio;
		
		//cantidad de presentaciones
		cantPres = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posicion+= TAMANIO_BYTE_DIN;
		for(int j=0;j<cantPres;j++)
		{
			string pres="",precio="";
			//PRESENTACION
			tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_PRES));
			posicion+=TAMANIO_BYTE_PRES;	
			pres =dato.substr(posicion,tamanio);
			posicion+=tamanio;
			//PRECIO
			tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
			posicion+=TAMANIO_BYTE_DIN;
			precio =dato.substr(posicion,tamanio);
			posicion+=tamanio;	
		}
		++i;		
	}
}
/*-----------------------------------------------------------*/
void CFichero::leerBloque(TIPO_DATO nroBloque)
{
	this->m_idxPrimario.leerBloque(nroBloque);	
}

/*-----------------------------------------------------------*/
void CFichero::leerBloque(string indice, TIPO_DATO nroBloque)
{
	switch (indice[0])
	{
		case '1':			
			this->m_idxPrimario.leerBloque(nroBloque);						
			break;
			
		case '2':  
			this->m_idxSecNombre.leerBloque(nroBloque);
			break;
			
		case '3': 
			this->m_idxSecMarca.leerBloque(nroBloque);
			break;
			
		case '4': 
			this->m_idxCandidata.leerBloque(nroBloque);
			break;					
		default: ;
	}
	
	
	
}
/*-----------------------------------------------------------*/
void CFichero::modificar(CProducto producto,TIPO_DATO nroBloque)
{
	string dato="";
	char bloque[TAMANIO_BLOQUE_DATO+1]={};
	int posicion=0, posFinal;
	CClavePrimaria primaria(producto.getRegistro(),nroBloque);
	if(!buscarDatos(primaria,dato,posicion))
	{
		cout<<"No se encontro los datos"<<endl;
		return;
	}
	obtenerProximoDatos(primaria.codProd,dato,posFinal);
	dato.replace(posicion,posFinal-posicion,producto.getRegistro());
	m_archivoDato.seekp(TAMANIO_BLOQUE_DATO*primaria.nroBloque,ios::beg);
	strncpy(bloque,dato.c_str(),TAMANIO_BLOQUE_DATO);  
	m_archivoDato.write(bloque,TAMANIO_BLOQUE_DATO);
	mostrar(bloque);

	/*DESPUES de hacer esto tendria que actualizar el tama�o de datos escritos.*/
}
void CFichero::mostrar(char bloque[])
{
	bool encontrado=false;
	int cantReg,i=0,tamanio=0,cantPres=0;
	TIPO_DATO codigoAux;
	string strcodProd="",dato="";
	dato.append(bloque);
	int posicion=0;
	cout<<endl;
	cout<<" <<<<<<<<<<<<<<<<<<<<MUESTRO EL ARCHIVO DE DATOS>>>>>>>>>>>>>>"<<endl;
	cantReg = (unsigned char)(dato.substr(posicion,TAMANIO_CANTIDAD_REGISTRO).c_str()[0]);
	if(cantReg ==0)
		posicion=0;
	posicion +=TAMANIO_CANTIDAD_REGISTRO;
	while(i<cantReg && !encontrado)
	{
		strcodProd = dato.substr(posicion,5); 
		codigoAux = atoi(strcodProd .c_str());
		cout<<"Codigo de Producto : "<<strcodProd<<endl;	
		posicion+=5;
		//MARCA
		tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));//LONGITUD
		posicion+=TAMANIO_BYTE_DIN;	//saltea el indicador de cual es la longitud
		strcodProd =dato.substr(posicion,tamanio); //para verificar
		cout<<"Marca : "<<strcodProd<<endl;
		posicion+=tamanio;
		//NOMBRE
		tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posicion+=TAMANIO_BYTE_DIN;			
		strcodProd =dato.substr(posicion,tamanio);		
		posicion+=tamanio;
		cout<<"Nombre : "<<strcodProd<<endl;
		
		//cantidad de presentaciones
		cantPres = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
		posicion+= TAMANIO_BYTE_DIN;
		cout<<endl;
		cout<<"Lista de "<<cantPres<<" presentaciones :"<<endl;
		cout<<endl;
		for(int j=0;j<cantPres;j++)
		{
			string pres="",precio="";
			//PRESENTACION
			tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_PRES));
			posicion+=TAMANIO_BYTE_PRES;	
			pres =dato.substr(posicion,tamanio);
			posicion+=tamanio;
			cout<<(j+1)<<" ).- Presentaci�n : "<<pres<<endl;
			//PRECIO
			tamanio = string2TipoDato(dato.substr(posicion,TAMANIO_BYTE_DIN));
			posicion+=TAMANIO_BYTE_DIN;
			precio =dato.substr(posicion,tamanio);
			posicion+=tamanio;
			cout<<(j+1)<<" ).- Precio : "<<precio<<endl;	
		}
		cout<<endl;
		++i;		
	}//fin del while
	cout<<" <<<<<<<<<<<<<<<<<<<<FIN DEL ARCH DE DATOS>>>>>>>>>>>>>>"<<endl;
	cout<<endl;
	cout<<"TAMANIO DEL ARCHIVO : "<<m_tamanioArch<<endl;
	//cout<<""<<<<endl;
	cout<<"ESPACIO LIBRES : "<<TAMANIO_BLOQUE_DATO -m_tamanioArch%TAMANIO_BLOQUE_DATO<<endl;
	cout<<"NUMERO DE BLOQUE : "<<m_tamanioArch/TAMANIO_BLOQUE_DATO<<endl;
	cout<<"-------------------------------------------------------------"<<endl;
	cout<<""<<endl;
	
}



TIPO_DATO CFichero::getNroBloque()
{
	if(m_tamanioArch%TAMANIO_BLOQUE_DATO==0 && m_tamanioArch!=0)
		return m_tamanioArch/TAMANIO_BLOQUE_DATO -1;
	return m_tamanioArch/TAMANIO_BLOQUE_DATO;
}

/*-----------------------------------------------------------*/
void CFichero::exportarArchivo(string opcion)
{
	string nombre = "";
	TIPO_DATO blqSig = 1; //inicializo en uno para que entre la primera vez
	string separadorBloques;	
	ofstream 	archExport;
	
	switch (opcion[0])
	{
		case '1':
			//Busco la primer hoja a procesar
			this->m_idxPrimario.buscarPrimeraHoja(blqSig);
			nombre = (string)NOM_ARCH_INDICE_PRIM + ".txt";	
			archExport.open(nombre.c_str(), ios::out| ios::trunc);
			
			//si la rama esta vacia el arbol no tenia datos.
			if(!this->m_idxPrimario.ramaEsVacia() && archExport.is_open())
			{								
				while ( blqSig != FIN_SET_SECUENCIAL )
				{
					//inicializo el vector de claves
					this->m_vectorClavesSet.clear();
					
					//carga el vector con las claves que contiene la hoja actual
					this->m_idxPrimario.getVectorClavesSet(blqSig, &this->m_vectorClavesSet);
					
					//recorre el vector llendo al archivo de datos por cada una de las claves 
					this->exportarVectorClavePrimaria(&archExport);					
				}				
				this->m_vectorClavesSet.clear();		
			}				
			break;
			
		case '2':  
			this->m_idxSecNombre.buscarPrimeraHoja(blqSig);
			nombre = (string)NOM_ARCH_INDICE_SEC_NOM + ".txt";
			archExport.open(nombre.c_str(), ios::out| ios::trunc);

			if(!this->m_idxSecNombre.ramaEsVacia() && archExport.is_open())
			{
				while ( blqSig != FIN_SET_SECUENCIAL )
				{
					//inicializo el vector de claves
					this->m_vectorClavesSet.clear();
					
					//carga el vector con las claves que contiene la hoja actual
					this->m_idxSecNombre.getVectorClavesSet(blqSig, &this->m_vectorClavesSet);
					
					//recorre el vector llendo al archivo de datos por cada una de las claves 
					this->exportarVectorClaveSecNombre(&archExport);					
				}				
				this->m_vectorClavesSet.clear();				
			}
			break;
			
		case '3': 
			this->m_idxSecMarca.buscarPrimeraHoja(blqSig);
			nombre = (string)NOM_ARCH_INDICE_SEC_MARC + ".txt";
			archExport.open(nombre.c_str(), ios::out| ios::trunc);
			
			if(!this->m_idxSecMarca.ramaEsVacia() && archExport.is_open())
			{
				while ( blqSig != FIN_SET_SECUENCIAL )
				{
					//inicializo el vector de claves
					this->m_vectorClavesSet.clear();
					
					//carga el vector con las claves que contiene la hoja actual
					this->m_idxSecMarca.getVectorClavesSet(blqSig, &this->m_vectorClavesSet);
					
					//recorre el vector llendo al archivo de datos por cada una de las claves 
					this->exportarVectorClaveSecMarca(&archExport);					
				}				
				this->m_vectorClavesSet.clear();	
			}			
			break;
			
		case '4': 
			this->m_idxCandidata.buscarPrimeraHoja(blqSig);
			nombre = (string)NOM_ARCH_INDICE_CAND + ".txt";
			archExport.open(nombre.c_str(), ios::out| ios::trunc);
			
			if(!this->m_idxCandidata.ramaEsVacia() && archExport.is_open())
			{
				while ( blqSig != FIN_SET_SECUENCIAL )
				{
					//inicializo el vector de claves
					this->m_vectorClavesSet.clear();
					
					//carga el vector con las claves que contiene la hoja actual
					this->m_idxCandidata.getVectorClavesSet(blqSig, &this->m_vectorClavesSet);
					
					//recorre el vector llendo al archivo de datos por cada una de las claves 
					this->exportarVectorClaveCandidata(&archExport);	
					
				}				
				this->m_vectorClavesSet.clear();	
			}
			break;	
				
		default: ;
	}
	if ( archExport.is_open() )
		archExport.close();
}
/*-----------------------------------------------------------*/
void CFichero::exportarVectorClavePrimaria(ofstream *archExport)
{
	CProducto unProducto;
	CClavePrimaria unaClave;
	
	if(archExport->is_open())
	{	
		TIPO_DATO cantElement = (TIPO_DATO)this->m_vectorClavesSet.size(), i = 0;
		while(i < cantElement)
		{
			unaClave = *(CClavePrimaria *)(this->m_vectorClavesSet[i++]); //(CClavePrimaria*)
			this->buscarDatos(unaClave, unProducto);
			unProducto.mostrar(*archExport);
		}
	}	
}

/*-----------------------------------------------------------*/
void CFichero::exportarVectorClaveSecNombre(ofstream *archExport)
{	
	list<CProducto*>			productos;
	list<CProducto*>::iterator	it;
	CClaveSecundaria unaClave;

	if(archExport->is_open())
	{	
		TIPO_DATO cantElement = (TIPO_DATO)this->m_vectorClavesSet.size(), i = 0;
		while(i < cantElement)
		{
			productos.clear(); //inicializo la lista de los productos correspondientes a una clave secundaria
			
			unaClave = *(CClaveSecundaria *)(this->m_vectorClavesSet[i++]);
			
			//obtengo una lista de los productos con ese nombre
			this->buscarSecNombre(unaClave/*.desTransformar()*/, productos); //B+++ comentar el desTransformar
			
			//muestro los productos con ese nombre
			for(it=productos.begin();it!=productos.end();it++)
			{
				(*it)->mostrar(*archExport);
				//(*it)->mostrarLista(*archExport);
			}			
		}
	}	
}

/*-----------------------------------------------------------*/
void CFichero::exportarVectorClaveSecMarca(ofstream *archExport)
{	
	list<CProducto*>			productos;
	list<CProducto*>::iterator	it;
	CClaveSecundaria unaClave;
	
	if(archExport->is_open())
	{	
		TIPO_DATO cantElement = (TIPO_DATO)this->m_vectorClavesSet.size(), i = 0;
		while(i < cantElement)
		{	
			productos.clear(); //inicializo la lista de los productos correspondientes a una clave secundaria
			
			unaClave = *(CClaveSecundaria *)(this->m_vectorClavesSet[i++]); 
			
			//obtengo una lista de los productos con ese nombre
			this->buscarSecMarca(unaClave/*.desTransformar()*/, productos);  //B+++ comentar .desTranformar()
			
			//muestro los productos con ese nombre
			for(it=productos.begin();it!=productos.end();it++)
			{
				(*it)->mostrar(*archExport);
				//(*it)->mostrarLista(*archExport);
			}			
		}
	}	
}

/*-----------------------------------------------------------*/
void CFichero::exportarVectorClaveCandidata(ofstream *archExport)
{	
	list<CProducto*>			productos;
	list<CProducto*>::iterator	it;
	CClaveCandidata unaClave;
	string aux;
	
	if(archExport->is_open())
	{	
		TIPO_DATO cantElement = (TIPO_DATO)this->m_vectorClavesSet.size(), i = 0;
		while(i < cantElement)
		{
			productos.clear(); //inicializo la lista de los productos correspondientes a una clave secundaria
			
			unaClave = *(CClaveCandidata *)(this->m_vectorClavesSet[i++]); 
			
			//obtengo una lista de los productos con ese nombre
				//aux ="";
				//aux = unaClave.desTransformar();
			this->buscarCandidata(unaClave, productos);
			
			//muestro los productos con ese nombre
			for(it=productos.begin();it!=productos.end();it++)
			{
				(*it)->mostrar(*archExport);
				//(*it)->mostrarLista(*archExport);
			}			
		}
	}	
}


/*-----------------------------------------------------------*/

void CFichero::AdministrarEspaciosLibres(TIPO_DATO tamInicial,TIPO_DATO tamFinal,TIPO_DATO nuevoEspLibre,TIPO_DATO  nroBloquePrim)
{

	/*MANEJO DE ESPACIOS LIBRES*/
	TIPO_DATO nroBloque,blAux=0;
	
	CClavePrimaria		*espacioSecAux = new CClavePrimaria(nroBloquePrim);
	
	if(!m_espacioSecDatos.buscar(*espacioSecAux,blAux))
	cout<<"el incide secundario no encontro el dato."<<endl;
	else
	{
		CClaveEspacioLibre  *espacio3 = new CClaveEspacioLibre(espacioSecAux->getNroBloque(),espacioSecAux->getClave());
		m_espacioDatos.eliminarElemVector(*espacio3);
		m_espacioSecDatos.eliminar(*espacioSecAux);
	}

	CClaveEspacioLibre  *espacio = new CClaveEspacioLibre(nuevoEspLibre ,nroBloquePrim);	
	m_espacioDatos.insertar(*espacio);

	CClavePrimaria		*espacioSec = new CClavePrimaria(nroBloquePrim,nuevoEspLibre);
	m_espacioSecDatos.insertar(*espacioSec);

	nroBloque = this->getNroBloque();
	if(nroBloque ==nroBloquePrim)
		m_tamanioArch -= (tamInicial -tamFinal);
}
void CFichero::eliminarClaves(string clave,TIPO_DATO mascara)
{
	string nombre,marca;
	TIPO_DATO blAux=0;

	if(mascara & CLAVE_PRIMARIA)
	{
		CClavePrimaria *primaria = new CClavePrimaria(clave);
		if(m_idxPrimario.eliminar(*primaria)==0)
			cout<<"El elemento que se trato de eliminar, no existe."<<endl;
	}
	if(mascara & CLAVE_SEC_NOMBRE)
	{
		CClaveSecundariaSec *secNombreSec = new CClaveSecundariaSec(clave);
		if(!m_idxSecNombreSec.buscar(*secNombreSec,blAux))
			cout<<"el incide secundario no encontro el dato."<<endl;
		else
			{
				CClaveSecundaria	*secNombre = new CClaveSecundaria(clave);//secundaria del nombre
				nombre =secNombreSec->getDescripcion();
				m_idxSecNombre.eliminarElemVector(*secNombre);
				m_idxSecNombreSec.eliminar(*secNombreSec);
			}
	}
	if(mascara & CLAVE_SEC_MARCA)
	{
		CClaveSecundariaSec *secMarcaSec = new CClaveSecundariaSec(clave,false);
		if(!m_idxSecMarcaSec.buscar(*secMarcaSec,blAux))
			cout<<"el incide secundario no encontro el dato."<<endl;
		else
			{
				CClaveSecundaria	*secMarca = new CClaveSecundaria(clave,false);//secundaria del Marca
				marca = secMarcaSec->getDescripcion();
				m_idxSecMarca.eliminarElemVector(*secMarca);
				m_idxSecMarcaSec.eliminar(*secMarcaSec);
			}
	}
	if(mascara & CLAVE_CANDIDATA)
	{
		CClaveCandidata		*candidata = new CClaveCandidata(nombre,marca);
		m_idxCandidata.eliminar(*candidata);
	}
}

/*-----------------------------------------------------------*/
void CFichero::inicializarCtoProc(void) //(CTO_PROC)
{
	this->m_costoProceso = 0;
	this->m_idxPrimario.inicializarCosto();
	this->m_idxSecMarca.inicializarCosto();
	this->m_idxSecNombre.inicializarCosto();
	this->m_idxCandidata.inicializarCosto();
}

/*-----------------------------------------------------------*/
void CFichero::mostrarCtoProc(void) //(CTO_PROC)
{
	cout<<endl<<"--------------------------------"<<endl;
	cout<<"-      Accesos Realizados      -"<<endl;
	cout<<"--------------------------------"<<endl;
	cout<<"- Archivo de Datos        : "<<this->getCosto()<<"  -"<<endl;
	cout<<"- Indice Primario         : "<<this->m_idxPrimario.getCosto()<<"  -"<<endl;
	cout<<"- Indice Secundario Marca : "<<this->m_idxSecMarca.getCosto()<<"  -"<<endl;
	cout<<"- Indice Secundario Nombre: "<<this->m_idxSecNombre.getCosto()<<"  -"<<endl;
	cout<<"- Indice Candidatas       : "<<this->m_idxCandidata.getCosto()<<"  -"<<endl;
	cout<<"--------------------------------"<<endl<<endl;
	
}


#endif //__FICHERO_H__


